// 全局变量
let selectorHistory = [];
let urlConfigs = []; // 存储URL配置
let editingConfigId = null; // 当前编辑的配置ID

$(document).ready(function() {
    // 显示页面信息
    updatePageInfo();
    
    // 从存储加载设置
    chrome.storage.local.get(['lastSelector', 'lastAttribute', 'extractBoth', 'extensionEnabled', 'selectorHistory', 'urlConfigs'], function(data) {
        if (data.lastSelector !== undefined) {
            $('#selector-input').val(data.lastSelector);
        }
        if (data.lastAttribute !== undefined) {
            $('#attribute-input').val(data.lastAttribute);
        }
        if (data.extractBoth !== undefined) {
            $('#extract-both').prop('checked', data.extractBoth);
        }
        if (data.extensionEnabled !== undefined) {
            $('#extension-toggle').prop('checked', data.extensionEnabled);
        }
        
        // 初始化选择器历史记录
        selectorHistory = data.selectorHistory || [];
        setupPopupSelectorHistory();
        
        // 初始化URL配置
        urlConfigs = data.urlConfigs || [];
        setupConfigManagement();
    });
    
    // 处理激活/禁用开关
    $('#extension-toggle').change(function() {
        const isEnabled = $(this).is(':checked');
        chrome.storage.local.set({extensionEnabled: isEnabled}, function() {
            // 通知所有标签页更新状态
            chrome.tabs.query({}, function(tabs) {
                tabs.forEach(tab => {
                    chrome.tabs.sendMessage(tab.id, {
                        action: 'toggleExtension',
                        enabled: isEnabled
                    }).catch(() => {
                        // 忽略无法发送消息的标签页（如chrome://页面）
                    });
                });
            });
            
            if (isEnabled) {
                showMessage('扩展已激活，悬浮H字母将显示在所有页面', 'success');
            } else {
                showMessage('扩展已禁用，悬浮H字母已隐藏', 'success');
            }
        });
    });
    
    // 自动加载当前页面HTML
    getCurrentPageHTML();
    
    // 获取当前页面HTML
    $('#get-html-btn').click(function() {
        getCurrentPageHTML();
    });
    
    // 加载示例
    $('#load-examples-btn').click(function() {
        loadPopupExample();
    });
    
    // 配置管理按钮
    $('#config-manage-btn').click(function() {
        showConfigModal();
    });
    
    // 自动填充按钮
    $('#auto-fill-btn').click(function() {
        autoFillFromConfig();
    });
    
    function getCurrentPageHTML() {
        showMessage('正在获取页面HTML...', 'success');
        
        chrome.tabs.query({active: true, currentWindow: true}, function(tabs) {
            if (!tabs || tabs.length === 0) {
                showError('无法获取当前标签页');
                return;
            }
            
            const tab = tabs[0];
            console.log("正在获取标签页HTML:", tab.id, tab.url);
            
            // 检查URL是否有效
            if (!tab.url || tab.url.startsWith('chrome://') || tab.url.startsWith('chrome-extension://') || tab.url.startsWith('moz-extension://')) {
                showError('无法在此类型的页面上获取HTML（Chrome内部页面或扩展页面）');
                return;
            }
            
            // 发送消息到content script
            chrome.tabs.sendMessage(tab.id, {action: "getHTML"}, function(response) {
                if (chrome.runtime.lastError) {
                    console.error("发送消息出错:", chrome.runtime.lastError);
                    
                    // 如果content script未注入，尝试手动注入
                    if (chrome.runtime.lastError.message.includes('Could not establish connection')) {
                        console.log("尝试注入content script...");
                        chrome.scripting.executeScript({
                            target: { tabId: tab.id },
                            files: ['content.js']
                        }, function() {
                            if (chrome.runtime.lastError) {
                                showError('无法注入内容脚本: ' + chrome.runtime.lastError.message);
                                return;
                            }
                            
                            // 重新发送消息
                            setTimeout(() => {
                                chrome.tabs.sendMessage(tab.id, {action: "getHTML"}, function(response) {
                                    handleHTMLResponse(response);
                                });
                            }, 100);
                        });
                    } else {
                        showError('无法与页面通信: ' + chrome.runtime.lastError.message);
                    }
                    return;
                }
                
                handleHTMLResponse(response);
            });
        });
    }
    
    function handleHTMLResponse(response) {
        if (response && response.success) {
            console.log("成功获取HTML，长度:", response.html.length);
            $('#html-input').val(response.html);
            updatePageInfo(response.url, response.title);
            showMessage('成功获取页面HTML', 'success');
        } else if (response && response.error) {
            showError('获取HTML出错: ' + response.error);
        } else {
            showError('无法获取页面HTML，可能是页面尚未加载完成或内容脚本未正确注入');
        }
    }
    
    function updatePageInfo(url, title) {
        if (url) {
            $('#page-url').text('当前页面: ' + url);
            $('#page-title').text('标题: ' + title);
        } else {
            chrome.tabs.query({active: true, currentWindow: true}, function(tabs) {
                if (tabs && tabs.length > 0) {
                    const tab = tabs[0];
                    $('#page-url').text('当前页面: ' + tab.url);
                    $('#page-title').text('标题: ' + tab.title);
                }
            });
        }
    }
    
    // 加载popup示例函数已在content.js中定义，这里不需要重复定义
    
    // 提取文本
    $('#extract-btn').click(function() {
        const htmlContent = $('#html-input').val();
        const selector = $('#selector-input').val();
        const attribute = $('#attribute-input').val();
        const extractBoth = $('#extract-both').is(':checked');
        
        // 保存最后使用的选择器、属性和设置
        chrome.storage.local.set({
            lastSelector: selector,
            lastAttribute: attribute,
            extractBoth: extractBoth
        });
        
        // 保存选择器到历史记录
        savePopupSelectorHistory(selector);
        
        if (!htmlContent.trim()) {
            showError('请先获取HTML内容');
            return;
        }
        
        if (!selector.trim()) {
            showError('请输入选择器');
            return;
        }
        
        try {
            // 创建临时DOM元素来解析HTML
            const $tempContainer = $('<div>').html(htmlContent);
            
            // 分割多个选择器
            const selectors = selector.split('|').map(s => s.trim()).filter(s => s);
            
            // 分割多个属性（如果提供了）
            const attributes = attribute ? attribute.split('|').map(a => a.trim()).filter(a => a) : [];
            
            // 确保选择器和属性数量匹配（除非是同时提取模式）
            if (attributes.length > 0 && attributes.length !== selectors.length && !extractBoth) {
                showError('选择器和属性数量必须匹配');
                return;
            }
            
            let results = [];
            
            if (extractBoth) {
                // 同时提取属性和文本模式
                results = selectors.map((sel, index) => {
                    const elements = $tempContainer.find(sel);
                    return elements.map(function() {
                        const $element = $(this);
                        const attrValue = attributes[index] ? ($element.attr(attributes[index]) || '') : '';
                        const textValue = $element.text().trim();
                        return `${attrValue}\t${textValue}`;
                    }).get();
                });
            } else {
                // 原有模式：要么提取属性，要么提取文本
                results = selectors.map((sel, index) => {
                    const elements = $tempContainer.find(sel);
                    return elements.map(function() {
                        const $element = $(this);
                        if (attributes.length > 0 && attributes[index]) {
                            // 提取属性值
                            return $element.attr(attributes[index]) || '';
                        } else {
                            // 提取文本内容
                            return $element.text().trim();
                        }
                    }).get();
                });
            }
            
            // 检查是否有结果
            if (results.some(arr => arr.length === 0)) {
                showError('某些选择器没有找到匹配的元素');
                return;
            }
            
            // 提取文本内容
            let resultText = '';
            const rowCount = Math.max(...results.map(arr => arr.length));
            
            for (let i = 0; i < rowCount; i++) {
                let rowText = '';
                selectors.forEach((sel, colIndex) => {
                    const value = results[colIndex][i] || '';
                    rowText += value + '\t';
                });
                resultText += rowText.trim() + '\n';
            }
            
            $('#result').val(resultText.trim());
            hideMessage('error');
            let extractType = '数据';
            if (extractBoth) {
                extractType = '属性和文本数据';
            } else if (attributes.length > 0) {
                extractType = '属性数据';
            } else {
                extractType = '文本数据';
            }
            showMessage(`成功提取 ${rowCount} 行${extractType}`, 'success');
            
        } catch (error) {
            showError('提取过程中发生错误: ' + error.message);
        }
    });
    
    function showError(message) {
        $('#error-message').text(message).show();
        $('#success-message').hide();
    }
    
    function showMessage(message, type) {
        if (type === 'error') {
            $('#error-message').text(message).show();
            $('#success-message').hide();
        } else {
            $('#success-message').text(message).show();
            $('#error-message').hide();
            // 3秒后自动隐藏成功消息
            setTimeout(() => {
                $('#success-message').fadeOut();
            }, 3000);
        }
    }
    
    function hideMessage(type) {
        if (type === 'error') {
            $('#error-message').hide();
        } else {
            $('#success-message').hide();
        }
    }
});

// 设置popup选择器历史记录功能
function setupPopupSelectorHistory() {
    const selectorInput = $('#selector-input');
    const historyDiv = $('#selector-history');
    
    if (selectorInput.length === 0 || historyDiv.length === 0) return;
    
    // 更新历史记录显示
    updatePopupSelectorHistoryDisplay();
    
    // 输入框获得焦点时显示历史记录
    selectorInput.on('focus', function() {
        showPopupSelectorHistory();
    });
    
    // 输入框失去焦点时隐藏历史记录（延迟一点时间，让点击历史项有时间执行）
    selectorInput.on('blur', function() {
        setTimeout(() => {
            hidePopupSelectorHistory();
        }, 200);
    });
    
    // 输入时过滤历史记录
    selectorInput.on('input', function() {
        filterPopupSelectorHistory($(this).val());
    });
    
    // 键盘事件处理
    selectorInput.on('keydown', function(e) {
        const historyItems = historyDiv.find('.history-item');
        const activeItem = historyDiv.find('.history-item.active');
        
        if (e.key === 'ArrowDown') {
            e.preventDefault();
            if (activeItem.length) {
                activeItem.removeClass('active');
                const nextItem = activeItem.next();
                if (nextItem.length) {
                    nextItem.addClass('active');
                } else if (historyItems.length > 0) {
                    historyItems.first().addClass('active');
                }
            } else if (historyItems.length > 0) {
                historyItems.first().addClass('active');
            }
        } else if (e.key === 'ArrowUp') {
            e.preventDefault();
            if (activeItem.length) {
                activeItem.removeClass('active');
                const prevItem = activeItem.prev();
                if (prevItem.length) {
                    prevItem.addClass('active');
                } else if (historyItems.length > 0) {
                    historyItems.last().addClass('active');
                }
            } else if (historyItems.length > 0) {
                historyItems.last().addClass('active');
            }
        } else if (e.key === 'Enter') {
            e.preventDefault();
            if (activeItem.length) {
                selectPopupHistoryItem(activeItem);
            }
        } else if (e.key === 'Escape') {
            hidePopupSelectorHistory();
        }
    });
}

// 保存popup选择器历史记录
function savePopupSelectorHistory(selector) {
    if (!selector || !selector.trim()) return;
    
    // 移除重复项
    selectorHistory = selectorHistory.filter(item => item !== selector);
    
    // 添加到开头
    selectorHistory.unshift(selector);
    
    // 限制最多10条记录
    if (selectorHistory.length > 10) {
        selectorHistory = selectorHistory.slice(0, 10);
    }
    
    // 保存到存储
    chrome.storage.local.set({selectorHistory: selectorHistory});
    
    // 更新显示
    updatePopupSelectorHistoryDisplay();
}

// 更新popup历史记录显示
function updatePopupSelectorHistoryDisplay() {
    const historyDiv = $('#selector-history');
    if (historyDiv.length === 0) return;
    
    if (selectorHistory.length === 0) {
        historyDiv.html('<div style="padding: 8px; color: #666; text-align: center;">暂无历史记录</div>');
        return;
    }
    
    // 清空历史记录容器
    historyDiv.empty();
    
    // 使用jQuery创建元素，避免模板字符串中的特殊字符问题
    selectorHistory.forEach((item, index) => {
        const historyItem = $('<div>')
            .addClass('history-item')
            .attr('data-selector', item) // 直接设置属性，jQuery会自动转义
            .css({
                'padding': '8px 12px',
                'cursor': 'pointer',
                'border-bottom': '1px solid #f0f0f0',
                'font-size': '14px',
                'transition': 'background-color 0.2s'
            });
        
        // 添加鼠标悬停效果
        historyItem.hover(
            function() { $(this).css('background-color', '#f5f5f5'); },
            function() { $(this).css('background-color', 'white'); }
        );
        
        // 创建内容
        const titleDiv = $('<div>')
            .css('font-weight', '500')
            .css('color', '#2c3e50')
            .text(item); // 使用text()安全设置文本
        
        const hintDiv = $('<div>')
            .css('font-size', '12px')
            .css('color', '#666')
            .css('margin-top', '2px')
            .text('点击选择');
        
        historyItem.append(titleDiv).append(hintDiv);
        historyDiv.append(historyItem);
    });
    
    // 添加点击事件
    historyDiv.find('.history-item').on('click', function() {
        selectPopupHistoryItem($(this));
    });
}

// 显示popup历史记录
function showPopupSelectorHistory() {
    const historyDiv = $('#selector-history');
    if (historyDiv.length && selectorHistory.length > 0) {
        historyDiv.show();
    }
}

// 隐藏popup历史记录
function hidePopupSelectorHistory() {
    const historyDiv = $('#selector-history');
    if (historyDiv.length) {
        historyDiv.hide();
        // 清除活动状态
        historyDiv.find('.history-item.active').removeClass('active');
    }
}

// 过滤popup历史记录
function filterPopupSelectorHistory(query) {
    const historyDiv = $('#selector-history');
    if (historyDiv.length === 0) return;
    
    const items = historyDiv.find('.history-item');
    const lowerQuery = query.toLowerCase();
    
    items.each(function() {
        const selector = $(this).attr('data-selector').toLowerCase();
        if (selector.includes(lowerQuery)) {
            $(this).show();
        } else {
            $(this).hide();
        }
    });
    
    // 显示或隐藏历史记录容器
    const visibleItems = items.filter(':visible');
    if (visibleItems.length > 0) {
        historyDiv.show();
    } else {
        historyDiv.hide();
    }
}


// 选择popup历史记录项
function selectPopupHistoryItem(item) {
    const selector = item.attr('data-selector');
    const selectorInput = $('#selector-input');
    
    if (selectorInput.length) {
        selectorInput.val(selector);
        selectorInput.focus();
        hidePopupSelectorHistory();
    }
}

// 加载popup示例
function loadPopupExample() {
    // 示例HTML内容
    const exampleHTML = `<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>商品展示示例</title>
    <style>
        .product-card {
            border: 1px solid #ddd;
            border-radius: 8px;
            padding: 20px;
            margin: 20px;
            max-width: 300px;
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        }
        .product-image {
            width: 100%;
            height: 200px;
            object-fit: cover;
            border-radius: 4px;
        }
        .product-title {
            font-size: 18px;
            font-weight: bold;
            margin: 10px 0;
            color: #333;
        }
        .product-link {
            color: #007bff;
            text-decoration: none;
            font-weight: 500;
        }
        .product-link:hover {
            text-decoration: underline;
        }
    </style>
</head>
<body>
    <div class="product-card">
        <img src="https://via.placeholder.com/300x200/4CAF50/FFFFFF?text=示例商品图片" 
             alt="商品图片" 
             class="product-image">
        <h3 class="product-title">优质商品标题</h3>
        <a href="https://example.com/product/123" 
           class="product-link" 
           target="_blank">
            查看商品详情
        </a>
    </div>
    
    <div class="product-card">
        <img src="https://via.placeholder.com/300x200/2196F3/FFFFFF?text=另一个商品" 
             alt="另一个商品图片" 
             class="product-image">
        <h3 class="product-title">另一个商品标题</h3>
        <a href="https://example.com/product/456" 
           class="product-link" 
           target="_blank">
            立即购买
        </a>
    </div>
</body>
</html>`;

    // 设置示例数据
    $('#selector-input').val('a | img');
    $('#attribute-input').val('href | src');
    $('#extract-both').prop('checked', true);
    $('#html-input').val(exampleHTML);
    
    // 显示成功消息
    showMessage('已加载示例数据！现在可以点击"提取文本"按钮查看效果', 'success');
    
    // 保存示例选择器到历史记录
    savePopupSelectorHistory('a | img');
}

// ==================== 配置管理功能 ====================

// 设置配置管理功能
function setupConfigManagement() {
    // 配置管理模态框事件
    $('#config-modal .close').click(function() {
        hideConfigModal();
    });
    
    // 标签页切换
    $('.tab-btn').click(function() {
        const tab = $(this).data('tab');
        switchTab(tab);
    });
    
    // 保存配置
    $('#save-config-btn').click(function() {
        saveConfig();
    });
    
    // 清空表单
    $('#clear-config-form-btn').click(function() {
        clearConfigForm();
    });
    
    // 搜索配置
    $('#search-config-btn').click(function() {
        searchConfigs();
    });
    
    // 导出配置
    $('#export-config-btn').click(function() {
        exportConfigsToExcel();
    });
    
    // 导入配置
    $('#import-config-btn').click(function() {
        importConfigsFromExcel();
    });
    
    // 文件选择变化
    $('#import-config-file').change(function() {
        const file = this.files[0];
        if (file) {
            $('#import-config-btn').prop('disabled', false);
        }
    });
}

// 显示配置管理模态框
function showConfigModal() {
    $('#config-modal').show();
    loadConfigList();
}

// 隐藏配置管理模态框
function hideConfigModal() {
    $('#config-modal').hide();
    editingConfigId = null;
    clearConfigForm();
}

// 切换标签页
function switchTab(tabName) {
    $('.tab-btn').removeClass('active');
    $('.tab-content').removeClass('active');
    
    $(`.tab-btn[data-tab="${tabName}"]`).addClass('active');
    $(`#tab-${tabName}`).addClass('active');
    
    if (tabName === 'list') {
        loadConfigList();
    }
}

// 加载配置列表
function loadConfigList() {
    const configList = $('#config-list');
    configList.empty();
    
    if (urlConfigs.length === 0) {
        configList.html('<div style="padding: 20px; text-align: center; color: #666;">暂无配置</div>');
        return;
    }
    
    urlConfigs.forEach((config, index) => {
        const configItem = $(`
            <div class="config-item" data-id="${index}">
                <div class="config-info">
                    <div class="config-url">${config.url}</div>
                    <div class="config-selector">选择器: ${config.selector}</div>
                    <div class="config-attribute">属性: ${config.attribute || '无'}</div>
                </div>
                <div class="config-actions">
                    <button class="edit-btn" data-action="edit" data-index="${index}">编辑</button>
                    <button class="delete-btn" data-action="delete" data-index="${index}">删除</button>
                </div>
            </div>
        `);
        configList.append(configItem);
    });
    
    // 绑定事件处理
    configList.find('.edit-btn').click(function() {
        const index = parseInt($(this).data('index'));
        editConfig(index);
    });
    
    configList.find('.delete-btn').click(function() {
        const index = parseInt($(this).data('index'));
        deleteConfig(index);
    });
}

// 保存配置
function saveConfig() {
    const url = $('#config-url').val().trim();
    const selector = $('#config-selector').val().trim();
    const attribute = $('#config-attribute').val().trim();
    const extractBoth = $('#config-extract-both').is(':checked');
    
    if (!url || !selector) {
        showMessage('请填写URL和选择器', 'error');
        return;
    }
    
    const config = {
        url: url,
        selector: selector,
        attribute: attribute,
        extractBoth: extractBoth,
        createdAt: new Date().toISOString()
    };
    
    if (editingConfigId !== null) {
        // 编辑现有配置
        urlConfigs[editingConfigId] = config;
        showMessage('配置已更新', 'success');
    } else {
        // 添加新配置
        urlConfigs.push(config);
        showMessage('配置已保存', 'success');
    }
    
    // 保存到存储
    chrome.storage.local.set({urlConfigs: urlConfigs}, function() {
        loadConfigList();
        clearConfigForm();
        editingConfigId = null;
    });
}

// 编辑配置
function editConfig(index) {
    const config = urlConfigs[index];
    $('#config-url').val(config.url);
    $('#config-selector').val(config.selector);
    $('#config-attribute').val(config.attribute);
    $('#config-extract-both').prop('checked', config.extractBoth);
    
    editingConfigId = index;
    switchTab('add');
}

// 删除配置
function deleteConfig(index) {
    // 创建确认对话框
    const confirmDialog = $(`
        <div class="confirm-dialog-overlay">
            <div class="confirm-dialog">
                <div class="confirm-title">确认删除</div>
                <div class="confirm-message">确定要删除这个配置吗？</div>
                <div class="confirm-buttons">
                    <button class="confirm-btn confirm-yes">确定</button>
                    <button class="confirm-btn confirm-no">取消</button>
                </div>
            </div>
        </div>
    `);
    
    $('body').append(confirmDialog);
    
    confirmDialog.find('.confirm-yes').click(function() {
        urlConfigs.splice(index, 1);
        chrome.storage.local.set({urlConfigs: urlConfigs}, function() {
            loadConfigList();
            showMessage('配置已删除', 'success');
        });
        confirmDialog.remove();
    });
    
    confirmDialog.find('.confirm-no').click(function() {
        confirmDialog.remove();
    });
    
    // 点击遮罩层关闭
    confirmDialog.click(function(e) {
        if (e.target === this) {
            confirmDialog.remove();
        }
    });
}

// 清空配置表单
function clearConfigForm() {
    $('#config-url').val('');
    $('#config-selector').val('');
    $('#config-attribute').val('');
    $('#config-extract-both').prop('checked', false);
    editingConfigId = null;
}

// 搜索配置
function searchConfigs() {
    const query = $('#config-search').val().toLowerCase();
    const configItems = $('.config-item');
    
    configItems.each(function() {
        const config = urlConfigs[$(this).data('id')];
        const text = (config.url + ' ' + config.selector + ' ' + (config.attribute || '')).toLowerCase();
        
        if (text.includes(query)) {
            $(this).show();
        } else {
            $(this).hide();
        }
    });
}

// 自动填充配置
function autoFillFromConfig() {
    chrome.tabs.query({active: true, currentWindow: true}, function(tabs) {
        if (!tabs || tabs.length === 0) {
            showMessage('无法获取当前页面信息', 'error');
            return;
        }
        
        const currentUrl = tabs[0].url;
        const config = findMatchingConfig(currentUrl);
        
        if (config) {
            $('#selector-input').val(config.selector);
            $('#attribute-input').val(config.attribute);
            $('#extract-both').prop('checked', config.extractBoth);
            showMessage(`已自动填充配置: ${config.url}`, 'success');
        } else {
            showMessage('未找到匹配的配置，使用最近使用的选择器', 'success');
            // 使用最近使用的选择器（已在初始化时加载）
        }
    });
}

// 查找匹配的配置
function findMatchingConfig(url) {
    // 1. 精确匹配
    let config = urlConfigs.find(c => c.url === url);
    if (config) return config;
    
    // 2. 域名匹配
    try {
        const urlObj = new URL(url);
        const domain = urlObj.hostname;
        config = urlConfigs.find(c => {
            try {
                const configUrlObj = new URL(c.url);
                return configUrlObj.hostname === domain;
            } catch (e) {
                return false;
            }
        });
        if (config) return config;
    } catch (e) {
        // URL解析失败，忽略
    }
    
    // 3. 如果没有找到，返回null，将使用最近使用的选择器
    return null;
}

// 导出配置到Excel
function exportConfigsToExcel() {
    if (urlConfigs.length === 0) {
        showMessage('没有配置可导出', 'error');
        return;
    }
    
    // 创建CSV内容
    let csvContent = 'URL,选择器,属性,同时提取属性和文本,创建时间\n';
    
    urlConfigs.forEach(config => {
        const row = [
            config.url,
            config.selector,
            config.attribute || '',
            config.extractBoth ? '是' : '否',
            new Date(config.createdAt).toLocaleString()
        ].map(field => `"${field}"`).join(',');
        csvContent += row + '\n';
    });
    
    // 创建下载链接
    const blob = new Blob(['\ufeff' + csvContent], { type: 'text/csv;charset=utf-8;' });
    const link = document.createElement('a');
    const url = URL.createObjectURL(blob);
    link.setAttribute('href', url);
    link.setAttribute('download', `html-extractor-configs-${new Date().toISOString().split('T')[0]}.csv`);
    link.style.visibility = 'hidden';
    document.body.appendChild(link);
    link.click();
    document.body.removeChild(link);
    
    showMessage('配置已导出为CSV文件', 'success');
}

// 从Excel导入配置
function importConfigsFromExcel() {
    const fileInput = $('#import-config-file')[0];
    const file = fileInput.files[0];
    
    if (!file) {
        showMessage('请选择要导入的文件', 'error');
        return;
    }
    
    const reader = new FileReader();
    reader.onload = function(e) {
        try {
            const csv = e.target.result;
            const lines = csv.split('\n');
            const newConfigs = [];
            
            // 跳过标题行
            for (let i = 1; i < lines.length; i++) {
                const line = lines[i].trim();
                if (!line) continue;
                
                // 简单的CSV解析（处理引号）
                const fields = parseCSVLine(line);
                if (fields.length >= 2) {
                    const config = {
                        url: fields[0],
                        selector: fields[1],
                        attribute: fields[2] || '',
                        extractBoth: fields[3] === '是' || fields[3] === 'true',
                        createdAt: new Date().toISOString()
                    };
                    newConfigs.push(config);
                }
            }
            
            if (newConfigs.length > 0) {
                // 创建确认对话框
                const confirmDialog = $(`
                    <div class="confirm-dialog-overlay">
                        <div class="confirm-dialog">
                            <div class="confirm-title">确认导入</div>
                            <div class="confirm-message">将导入 ${newConfigs.length} 个配置，这将覆盖现有配置。确定继续吗？</div>
                            <div class="confirm-buttons">
                                <button class="confirm-btn confirm-yes">确定</button>
                                <button class="confirm-btn confirm-no">取消</button>
                            </div>
                        </div>
                    </div>
                `);
                
                $('body').append(confirmDialog);
                
                confirmDialog.find('.confirm-yes').click(function() {
                    urlConfigs = newConfigs;
                    chrome.storage.local.set({urlConfigs: urlConfigs}, function() {
                        loadConfigList();
                        showMessage(`成功导入 ${newConfigs.length} 个配置`, 'success');
                        fileInput.value = '';
                    });
                    confirmDialog.remove();
                });
                
                confirmDialog.find('.confirm-no').click(function() {
                    confirmDialog.remove();
                });
                
                // 点击遮罩层关闭
                confirmDialog.click(function(e) {
                    if (e.target === this) {
                        confirmDialog.remove();
                    }
                });
            } else {
                showMessage('没有找到有效的配置数据', 'error');
            }
        } catch (error) {
            showMessage('导入失败: ' + error.message, 'error');
        }
    };
    
    reader.readAsText(file, 'utf-8');
}

// 简单的CSV行解析
function parseCSVLine(line) {
    const fields = [];
    let current = '';
    let inQuotes = false;
    
    for (let i = 0; i < line.length; i++) {
        const char = line[i];
        
        if (char === '"') {
            inQuotes = !inQuotes;
        } else if (char === ',' && !inQuotes) {
            fields.push(current.trim());
            current = '';
        } else {
            current += char;
        }
    }
    
    fields.push(current.trim());
    return fields;
}